export const post = (url: string, params: object = {}) => {
	return new Promise((resove, reject) => {
		// 获取token，优先从H5登录数据获取，兼容小程序token
		let token = '';
		const h5LoginData = uni.getStorageSync('h5_login_data');
		if (h5LoginData) {
			try {
				const loginData = JSON.parse(h5LoginData);
				token = loginData.token || '';
				console.log('post从h5_login_data获取到token:', token);
			} catch (e) {
				console.error('解析H5登录数据失败:', e);
			}
		}
		
		// 如果没有H5登录数据，则使用小程序token
		if (!token) {
			token = uni.getStorageSync('token') || '';
			console.log('post从小程序token获取到token:', token);
		}
		
		// 兼容旧的h5_token
		if (!token) {
			token = uni.getStorageSync('h5_token') || '';
			console.log('post从h5_token获取到token:', token);
		}
		
		console.log('post最终使用的token:', token);
		
		uni.request({
			url,
			data: params,
			header: {
				'ba-user-token': token,
				'server':1,
			},
			method: 'POST',
			timeout: 20000,
			success(res: any) {
				console.log(res,params,url,999)
				switch (res.data.code) {
					case 1001:
					
					break
					case 500:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					case 403:
					uni.showToast({
						icon: "none",
						title: "用户已被禁用"
					})
					uni.removeStorageSync('token')
					setTimeout(() => {
						uni.reLaunch({
							url: '/pages/index/index'
						})
					}, 1500)
					break
					case 303:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/h5login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/h5login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 409:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 600:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					
					default:
						resove(res.data)
				}
			},
			fail(err: any) {
				console.log(err,2112)
				switch (err.data.code) {
					default:
						resove(err.data)
				}
				reject(err)
			},
			complete(res: any) {
				if (res.errMsg == "request:fail timeout") {
					uni.showToast({
						title: "请求已超时!",
						icon: "none"
					})
				}
			}
		})
	})
}

export const postLoading = (url: string, params: object = {}) => {
	return new Promise((resove, reject) => {
		// 获取token，优先从H5登录数据获取，兼容小程序token
		let token = '';
		const h5LoginData = uni.getStorageSync('h5_login_data');
		if (h5LoginData) {
			try {
				const loginData = JSON.parse(h5LoginData);
				token = loginData.token || '';
				console.log('postLoading从h5_login_data获取到token:', token);
			} catch (e) {
				console.error('解析H5登录数据失败:', e);
			}
		}
		
		// 如果没有H5登录数据，则使用小程序token
		if (!token) {
			token = uni.getStorageSync('token') || '';
			console.log('postLoading从小程序token获取到token:', token);
		}
		
		// 兼容旧的h5_token
		if (!token) {
			token = uni.getStorageSync('h5_token') || '';
			console.log('postLoading从h5_token获取到token:', token);
		}
		
		console.log('postLoading最终使用的token:', token);
		
		uni.showLoading({
			mask: true,
			title: '加载中',
		})
		uni.request({
			url,
			data: params,
			header: {
				'ba-user-token': token,
				'server':1,
			},
			method: 'POST',
			timeout: 20000,
			success(res: any) {
				uni.hideLoading()
				switch (res.data.code) {
					case 1001:
					
					break
					case 500:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					case 403:
					uni.showToast({
						icon: "none",
						title: "用户已被禁用"
					})
					uni.removeStorageSync('token')
					setTimeout(() => {
						uni.reLaunch({
							url: '/pages/index/index'
						})
					}, 1500)
					break
					case 303:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 409:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 600:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					
					default:
						resove(res.data)
				}
			},
			fail(err: any) {
				switch (err.data.code) {
							case 403:
							uni.showToast({
								icon: "none",
								title: "用户已被禁用"
							})
							uni.removeStorageSync('token')
							setTimeout(() => {
								uni.reLaunch({
									url: '/pages/index/index'
								})
							}, 1500)
							break
					default:
						resove(err.data)
				}
				uni.hideLoading()
				reject(err)
			},
			complete(res: any) {
				if (res.errMsg == "request:fail timeout") {
					uni.showToast({
						title: "请求已超时!",
						icon: "none"
					})
				}
			}
		})
	})
}

export const get = (url: string, params: object = {}) => {
	return new Promise((resove, reject) => {
		// 获取token，优先从H5登录数据获取，兼容小程序token
		let token = '';
		const h5LoginData = uni.getStorageSync('h5_login_data');
		if (h5LoginData) {
			try {
				const loginData = JSON.parse(h5LoginData);
				token = loginData.token || '';
				console.log('get从h5_login_data获取到token:', token);
			} catch (e) {
				console.error('解析H5登录数据失败:', e);
			}
		}
		
		// 如果没有H5登录数据，则使用小程序token
		if (!token) {
			token = uni.getStorageSync('token') || '';
			console.log('get从小程序token获取到token:', token);
		}
		
		// 兼容旧的h5_token
		if (!token) {
			token = uni.getStorageSync('h5_token') || '';
			console.log('get从h5_token获取到token:', token);
		}
		
		console.log('get最终使用的token:', token);
		
		uni.showLoading({
			mask: true,
			title: '加载中',
			})
		uni.request({
			url,
			data: params,
			header: {
				'ba-user-token': token,
				'server':1,
			},
			method: 'GET',
			timeout: 20000,
			success(res: any) {
				uni.hideLoading()
				resove(res.data)
				switch (res.data.code) {
					case 1001:
					
					break
					case 500:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					case 403:
					uni.showToast({
						icon: "none",
						title: "用户已被禁用"
					})
					uni.removeStorageSync('token')
					setTimeout(() => {
						uni.reLaunch({
							url: '/pages/index/index'
						})
					}, 1500)
					break
					case 303:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 409:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 600:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					
					default:
						resove(res.data)
				}
			},
			fail(err: any) {
				reject(err)
			},
			complete(res: any) {
				uni.hideLoading()
				if (res.errMsg == "request:fail timeout") {
					uni.showToast({
						title: "请求已超时!",
						icon: "none"
					})
				}
			}
		})
	})
}

export const getnolog = (url: string, params: object = {}) => {
	return new Promise((resove, reject) => {
		// 获取token，优先从H5登录数据获取，兼容小程序token
		let token = '';
		const h5LoginData = uni.getStorageSync('h5_login_data');
		if (h5LoginData) {
			try {
				const loginData = JSON.parse(h5LoginData);
				token = loginData.token || '';
				console.log('getnolog从h5_login_data获取到token:', token);
			} catch (e) {
				console.error('解析H5登录数据失败:', e);
			}
		}
		
		// 如果没有H5登录数据，则使用小程序token
		if (!token) {
			token = uni.getStorageSync('token') || '';
			console.log('getnolog从小程序token获取到token:', token);
		}
		
		// 兼容旧的h5_token
		if (!token) {
			token = uni.getStorageSync('h5_token') || '';
			console.log('getnolog从h5_token获取到token:', token);
		}
		
		console.log('getnolog最终使用的token:', token);
		
		uni.request({
			url,
			data: params,
			header: {
				'ba-user-token': token,
				'server':1,
			},
			method: 'GET',
			timeout: 20000,
			success(res: any) {
				resove(res.data)
				switch (res.data.code) {
					case 1001:
					
					break
					case 500:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					case 403:
					uni.showToast({
						icon: "none",
						title: "用户已被禁用"
					})
					uni.removeStorageSync('token')
					setTimeout(() => {
						uni.reLaunch({
							url: '/pages/index/index'
						})
					}, 1500)
					break
					case 303:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 409:
					if (uni.getStorageSync('token')) {
						uni.removeStorageSync("token")
						uni.showToast({
							icon: "none",
							title: "登录已失效，请重新登录"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					} else {
						uni.showToast({
							icon: "none",
							title: "请登录后使用"
						})
						setTimeout(() => {
							uni.reLaunch({
								url: '/pages/login/login'
							})
						}, 1500)
					}
					resove(res.data)
					break
					case 600:
					uni.showToast({
						icon: "none",
						title:res.data.msg
					})
					break
					
					default:
						resove(res.data)
				}
			},
			fail(err: any) {
				reject(err)
			},
			complete(res: any) {
				uni.hideLoading()
				if (res.errMsg == "request:fail timeout") {
					uni.showToast({
						title: "请求已超时!",
						icon: "none"
					})
				}
			}
		})
	})
}

export const uploadFile = (url: string, filePath: string) => {
	// 获取token，优先从H5登录数据获取，兼容小程序token
	let token = '';
	const h5LoginData = uni.getStorageSync('h5_login_data');
	if (h5LoginData) {
		try {
			const loginData = JSON.parse(h5LoginData);
			token = loginData.token || '';
			console.log('uploadFile从h5_login_data获取到token:', token);
		} catch (e) {
			console.error('解析H5登录数据失败:', e);
		}
	}
	
	// 如果没有H5登录数据，则使用小程序token
	if (!token) {
		token = uni.getStorageSync('token') || '';
		console.log('uploadFile从小程序token获取到token:', token);
	}
	
	// 兼容旧的h5_token
	if (!token) {
		token = uni.getStorageSync('h5_token') || '';
		console.log('uploadFile从h5_token获取到token:', token);
	}
	
	console.log('uploadFile最终使用的token:', token);
	
	const lang: string = uni.getStorageSync('lang') || ''
	return new Promise((resove, reject) => {
		uni.uploadFile({
			url,
			filePath,
			name: 'file',
			header: {
				'ba-user-token': token,
				'server':1,
			},
			fileType:'image',
			timeout: 20000,
			success: (res: any) => {
				let data = JSON.parse(res.data)
				resove(data)
			},
			fail: (err: any) => {
				reject(err)
			},
			complete: (res: any) => {
				if (res.errMsg == "request:fail timeout") {
					uni.showToast({
						title: "上传已超时!",
						icon: "none"
					})
				}
			}
		})
	})
}

